Elasticsearch7.8.0

很完整的课程参考文档：https://blog.csdn.net/SeniorShen/article/details/111591122，这里面的内容可以参考一下，总结的还是不错

1. 简介

   • 互联网的数据一般分为图片、文章、视频、网站信息，一般根据数据的格式会将数据分成三个大类，结构化数据、非结构化数据、半结构化数据

   • 结构化数据使用特定的结构如二维表结构来组织和管理数据，一般这些数据间都有关系，使用关系型数据库Mysql、Oracle，通过sql语句来查询数据并使用索引对查询进行优化，这种方式方便管理和查询，但是扩展结构很难；

   • 非结构化数据无法使用二维表结构来表现数据，如服务器日志、通信记录、工作文档、报表、视频、图片等维度广、数据量大，数据存储和查询的成本很大，这种数据一般存在存入nosql数据库中，如MongoDB、Redis、DataBase，以key-value结构保存，通过key查询对应数据，相对来说比较快，这种数据一般需要专业的人员和大量的统计模型来进行处理；

   • 半结构化数据是将数据和结构混合在一起，没有明显的区分，比如xml、html，这种文档就是半结构化数据，这种数据一般也是保存在MongoDB、Redis、DataBase中，缺点是查询其中的数据内容不是很方便；ES用户解决实时准确地查询任何来源、任何格式的数据【同时包含结构化数据和非结构化数据】，然后实时地对数据进行搜索、分析和可视化的问题

   • EalsticSearch解决的就是如何准确查询结构化数据和非结构化数据的问题，开源的Elasticsearch是目前全文搜索引擎的首选。它可以快速地存储、搜索和分析海量数据。 维基百科、Stack Overflow、Github都采用它。 Elastic的底层是开源库Lucene【Lucene是使用java开发的】，Elastic是Lucene的封装，提供了REST API的操作接口，开箱即用。全文搜索又叫全站搜索，用户可以根据热门词汇查询整个网站中的热门文章并以列表的形式展现结果

   • ES请求和响应体的数据都是json串的格式，数据发送和返回都是json格式，json全称JavaScript Object Notation，表示一种特殊标记的JavaScript对象；json格式特别适合将对象用字符串进行网络传递；而一个对象无法使用网络传递，只能通过序列化后传递然后在客户端反序列化为对象，比较麻烦；json字符串就是网络传递数据的字符串符合json格式的字符串

   • 官方文档：[Elasticsearch Guide 8.13] | Elastic

   • 官方中文文档：Elasticsearch: 权威指南 | Elastic

   • ElasticSearch将Apache的Lucene封装到REST API级别，封装度非常高，不像MySQL一样需要引入配置驱动包，编写CRUD代码

HTTP API

以下使用Postman测试，实际生产中可以内嵌到网页中来发起请求提交和查询数据

1. http://localhost:9200【Get】

   • 测试ES的HTTP协议的RestFul端口

2. http://127.0.0.1:9200/shopping【PUT】

   • ES创建索引，等同于创建数据库

   • 幂等性，重复发起报错

3. http://127.0.0.1:9200/_cat/indices?v【GET】

   • 查看ES中的所有索引

4. http://127.0.0.1:9200/shopping【GET】

   • 查看单个索引的内容简介【不包含数据】

5. http://127.0.0.1:9200/shopping【DELETE】

   • 删除ES中单个索引

6. http://127.0.0.1:9200/shopping/_doc【POST】【请求体提交JSON格式数据】

   • 索引已经创建好了，接下来我们来创建文档，并添加数据，数据格式为json，这种方式生成的文档数据的标识是随机唯一标识，不指定主键ID的文档数据添加不能为PUT方式，会报错

   • http://127.0.0.1:9200/shopping/_doc/1【POST】【请求体提交JSON格式数据】，指定自定义唯一标识主键ID的文档数据添加，明确数据主键的请求方式可以为PUT，两种请求方式都可以，区别不明确主键的方式

7. http://127.0.0.1:9200/shopping/_doc/1【GET】

   • 根据文档的唯一主键标识让ES服务器返回对应的文档数据，文档数据在_source属性中，传入什么内容，响应_source属性内容就是什么内容

8. http://127.0.0.1:9200/shopping/_search【GET】

   • 查看单个索引下的所有文档数据，单个查看的响应结果以json数组的方式赋值给hits.hits属性

9. http://127.0.0.1:9200/shopping/_doc/1【POST】【请求体提交JSON格式数据】

   • 全量修改，带唯一标识主键ID，会将原来数据完全覆盖

   • 请求体json

     xxxxxxxxxx
     {
         "title":"华为手机",
         "category":"华为",
         "images":"http://www.gulixueyuan.com/hw.jpg",
         "price":1999.00
     }
     

10. http://127.0.0.1:9200/shopping/_update/1【POST】【请求体提交JSON格式数据】

    • 局部修改，在json对象的doc属性中传递需要修改的数据

    • 请求体json

      xxxxxxxxxx
      {
          "doc": {
              "title":"小米手机",
              "category":"小米"
          }
      }
      

11. http://127.0.0.1:9200/shopping/_doc/1【DELETE 】

    • 删除索引下对应主键的文档数据，删除一个文档不会立即从磁盘上移除，它只是被标记成已删除（逻辑删除）

12. http://127.0.0.1:9200/shopping/_search?q=category:小米【GET】

    • 查询索引shopping下的文档数据中包含属性category为小米的所有文档数据，响应也是响应所有满足条件的数据显示在hits.hits中

    • URL带参数形式查询，不善者容易搞攻击，或参数值出现中文可能乱码。避免这些情况可使用带JSON请求体请求进行查询

13. http://127.0.0.1:9200/shopping/_search【GET】

    woc，GET请求可以带请求体

    • 查询文档中满足属性category的值为小米的请求体JSON

      xxxxxxxxxx
      {
          "query":{
              "match":{
                  "category":"小米"
              }
          }
      }
      

    • 查询对应索引下的所有文档数据的请求体JSON

      xxxxxxxxxx
      {
          "query":{
              "match_all":{}
          }
      }
      

    • 查询索引下所有结果文档数据并只显示文档数据指定属性的JSON

      "_source":["title"]表示只显示_source属性下的title属性

      xxxxxxxxxx
      {
          "query":{
              "match_all":{}
          },
          "_source":["title"]
      }
      

    • 查询索引下所有内容并分页显示的请求体JSON

      from是当前页的第一条数据的条数，满足(页数-1)*每页展示条数，比如下面的例子就是(2-1)*2，表示展示第二页数据，每页展示两条数据，响应索引下总的数据条数和当前页需要展示的数据

      xxxxxxxxxx
      {
          "query":{
              "match_all":{}
          },
          "from":2,
          "size":2
      }
      

    • 同一个索引下的查询结果根据某个属性进行排序的请求体JSON

      sort.price.order表示使用文档数据的price属性来进行排序

      xxxxxxxxxx
      {
          "query":{
              "match_all":{}
          },
          "sort":{
              "price":{
                  "order":"desc"
              }
          }
      }
      

14. http://127.0.0.1:9200/shopping/_search【GET】【请求体JSON数据】

    对一个索引下的文档数据多条件查询

    • 多条件同时满足【交集】使用must的请求体JSON

      must相当于数据库的&&，查询文档数据中同时包含"category":"小米"和"price":3999.00的文档数据

      xxxxxxxxxx
      {
          "query":{
              "bool":{
                  "must":[{
                      "match":{
                          "category":"小米"
                      }
                  },{
                      "match":{
                          "price":3999.00
                      }
                  }]
              }
          }
      }
      

    • 满足多条件中的一个【并集】使用should的请求体JSON

      should相当于数据库的||，查询文档数据中包含"category":"小米"或者"category":"华为"的文档数据

      xxxxxxxxxx
      {
          "query":{
              "bool":{
                  "should":[{
                      "match":{
                          "category":"小米"
                      }
                  },{
                      "match":{
                          "category":"华为"
                      }
                  }]
              }
          }
      }
      

    • 满足范围查询使用filter的请求体json

      filter.range表示范围查询，price表示根据price属性进行范围查询，"gt":2000表示大于2000；即对查询结果中文档数据的price属性大于2000的数据进行展示

      xxxxxxxxxx
      {
          "query":{
              "bool":{
                  "should":[{
                      "match":{
                          "category":"小米"
                      }
                  },{
                      "match":{
                          "category":"华为"
                      }
                  }],
                  "filter":{
                      "range":{
                          "price":{
                              "gt":2000
                          }
                      }
                  }
              }
          }
      }
      

15. http://127.0.0.1:9200/shopping/_search【GET】【请求体：JSON数据】

    • 全文检索的请求体JSON

      • 像搜索引擎一样，查询匹配内容输入“小华”，返回结果带回品牌有“小米”和"华为"，原因是ES对match条件中的数据匹配时会将查询请求需要匹配的属性值拆分成一个单独的字符，对每个字符都进行单独匹配再汇总，"category" : "小米"只会查询到category属性下能匹配上小的文档数据和能匹配上米的文档数据，取并集进行输出；"category" : "小华"会查询匹配文档数据中能匹配小字的文档数据和能匹配上华字的文档数据并求并集返回

      • json数据

        xxxxxxxxxx
        {
            "query":{
                "match":{
                    "category" : "小华"
                }
            }
        }
        

    • 完全匹配

      • 会精确地去匹配输出的查询条件，此时对match_phrase输入的属性值会去精确匹配文档数据，比如匹配"category" : "小华"就会精确地找文档中的category属性含有小华的文档数据

      • json数据

        下面的匹配条件就会返回文档数据总数为0，如果是match匹配会返回category属性含有小米和华为的文档数据的并集

        xxxxxxxxxx
        {
            "query":{
                "match_phrase":{
                    "category" : "小华"
                }
            }
        }
        

    • 高亮查询

      用hightlight属性指定查询数据的某个属性的属性值高亮显示的json请求体数据，就是在对应的内容两边添加html标签，每个文字都会添加这个标签，为什么不一起添加该标签?

      以下就是查询shopping索引下的category属性值匹配"为"的文档数据

      • json数据

        xxxxxxxxxx
        {
            "query":{
                "match_phrase":{
                    "category" : "为"
                }
            },
            "highlight":{
                "fields":{
                    "category":{}//<----高亮category这字段
                }
            }
        }
        

16. http://127.0.0.1:9200/shopping/_search【GET】【请求体：json数据】

    • 聚合查询

      允许使用者对es文档进行统计分析，类似与关系型数据库中的group by，当然还有很多其他的聚合，例如取最大值max、平均值avg等等，就是根据指定的属性值分组，对每一组的文档数量进行计数

      • 带回索引下满足条件的完整文档内容和统计数据的请求体JSON

        响应数据中仍然是hits.hits中是所有的文档数据，在aggregations.buckets中是对应的分组数据，分组只显示对应的分组属性值和相应的数量

        请求体json中的"terms"的含义是根据内部指定字段对数据进行分组，内部写分组依据的字段

        xxxxxxxxxx
        {
            "aggs":{//聚合操作
                "price_group":{//名称，随意起名
                    "terms":{//分组
                        "field":"price"//分组字段
                    }
                }
            }
        }
        

      • 不带回文档数据只带回统计数据的请求体JSON

        加了size属性的属性值为0，响应的hits.hits就是空串

        xxxxxxxxxx
        {
            "aggs":{
                "price_group":{
                    "terms":{
                        "field":"price"
                    }
                }
            },
            "size":0
        }
        

      • 对指定属性值求平均值的请求体

        xxxxxxxxxx
        {
            "aggs":{
                "price_avg":{//名称，随意起名
                    "avg":{//求平均
                        "field":"price"
                    }
                }
            },
            "size":0
        }
        

17. http://localhost:1004/_cluster/health【GET】集群中某个节点和整个集群的状态检查

    • 响应内容

      注意，更改了ES集群中某个节点的配置文件【端口号】，需要将ES文件的数据目录删掉，否则查询集群健康状态会报错error并响应状态码503

      • "status": "green",表示集群状态正常

      • "number_of_nodes": 1,表示当前集群节点数量为1

      • "number_of_data_nodes": 1,表示当前数据节点数量为1

      xxxxxxxxxx
      {
          "cluster_name": "my-application",
          "status": "green",
          "timed_out": false,
          "number_of_nodes": 1,
          "number_of_data_nodes": 1,
          "active_primary_shards": 0,
          "active_shards": 0,
          "relocating_shards": 0,
          "initializing_shards": 0,
          "unassigned_shards": 0,
          "delayed_unassigned_shards": 0,
          "number_of_pending_tasks": 0,
          "number_of_in_flight_fetch": 0,
          "task_max_waiting_in_queue_millis": 0,
          "active_shards_percent_as_number": 100.0
      }
      

Java API

1. 环境搭建

   • 创建maven项目并配置pom.xml

     xxxxxxxxxx
     <dependencies>
         <dependency>
             <groupId>org.elasticsearch</groupId>
             <artifactId>elasticsearch</artifactId>
             <version>7.8.0</version>
         </dependency>
         <!-- elasticsearch 的客户端，elasticsearch中获取客户端的方法已经过时了，官方说在8.x版本会将其移除，这里使用elasticsearch-rest-
         high-level-client中获取客户端的工具类 -->
         <dependency>
             <groupId>org.elasticsearch.client</groupId>
             <artifactId>elasticsearch-rest-high-level-client</artifactId>
             <version>7.8.0</version>
         </dependency>
         <!-- elasticsearch 依赖 2.x 的 log4j -->
         <dependency>
             <groupId>org.apache.logging.log4j</groupId>
             <artifactId>log4j-api</artifactId>
             <version>2.8.2</version>
         </dependency>
         <dependency>
             <groupId>org.apache.logging.log4j</groupId>
             <artifactId>log4j-core</artifactId>
             <version>2.8.2</version>
         </dependency>
         <dependency>
             <groupId>com.fasterxml.jackson.core</groupId>
             <artifactId>jackson-databind</artifactId>
             <version>2.9.9</version>
         </dependency>
         <!-- junit 单元测试 -->
         <dependency>
             <groupId>junit</groupId>
             <artifactId>junit</artifactId>
             <version>4.12</version>
         </dependency>
     </dependencies>
     

   • 对应文档数据的实体类

     ​x
     /**
      * @author Earl
      * @version 1.0.0
      * @描述 准备vo来封装数据模型
      * @创建日期 2024/01/23
      * @since 1.0.0
      */
     public class User {
         private String name;
         private String sex;
         private Integer age;
     
         public String getName() {
             return name;
         }
     
         public void setName(String name) {
             this.name = name;
         }
     
         public String getSex() {
             return sex;
         }
     
         public void setSex(String sex) {
             this.sex = sex;
         }
     
         public Integer getAge() {
             return age;
         }
     
         public void setAge(Integer age) {
             this.age = age;
         }
     }
     

2. 创建操作ES的客户端

   xxxxxxxxxx
   public class ESTest01_Client {
       /**
        * @param args
        * @描述 创建ES客户端的JAVA-API并测试链接，需要ES服务器开启，不报错就是对象创建成功即链接成功
        * @author Earl
        * @version 1.0.0
        * @创建日期 2024/01/23
        * @since 1.0.0
        */
       public static void main(String[] args) throws Exception {
   
           // 创建ES客户端
           //TransportClient创建ES客户端的工具已经过时，并且在8.x的版本会正式删除，这里不使用TransportClient，
           // 使用elasticsearch-rest-high-level-client中的RestHighLevelClient
           //创建ES客户端
           RestHighLevelClient esClient = new RestHighLevelClient(
                   RestClient.builder(new HttpHost("localhost", 9200, "http"))
           );
   
           // 关闭ES客户端
           esClient.close();
       }
   }
   

3. 创建索引

   xxxxxxxxxx
   public class ESTest02_Index_Create {
       /**
        * @param args
        * @描述 通过javaAPI在ES服务器上创建索引
        * @author Earl
        * @version 1.0.0
        * @创建日期 2024/01/23
        * @since 1.0.0
        */
       public static void main(String[] args) throws Exception {
   
           RestHighLevelClient esClient = new RestHighLevelClient(
                   RestClient.builder(new HttpHost("localhost", 9200, "http"))
           );
   
           // 创建索引
           CreateIndexRequest request = new CreateIndexRequest("user");
           CreateIndexResponse createIndexResponse =
                   esClient.indices().create(request, RequestOptions.DEFAULT);
   
           // 响应状态,返回响应的内容中的acknowledged属性，成功创建返回true
           boolean acknowledged = createIndexResponse.isAcknowledged();
           System.out.println("索引操作 ：" + acknowledged);
   
           esClient.close();
       }
   }
   

4. 查询索引

   xxxxxxxxxx
   public class ESTest03_Index_Search {
       /**
        * @param args
        * @描述 获取索引信息，不包含索引下的文档内容
        * @author Earl
        * @version 1.0.0
        * @创建日期 2024/01/23
        * @since 1.0.0
        */
       public static void main(String[] args) throws Exception {
   
           RestHighLevelClient esClient = new RestHighLevelClient(
                   RestClient.builder(new HttpHost("localhost", 9200, "http"))
           );
   
           // 查询索引
           GetIndexRequest request = new GetIndexRequest("user");
   
           GetIndexResponse getIndexResponse =
                   esClient.indices().get(request, RequestOptions.DEFAULT);
   
           // 响应内容，和postman发起的请求是一样的，后面三个对应响应内容的三个属性
           System.out.println(getIndexResponse.getAliases());
           System.out.println(getIndexResponse.getMappings());
           System.out.println(getIndexResponse.getSettings());
   
           esClient.close();
       }
   }
   

5. 删除索引

   xxxxxxxxxx
   public class ESTest04_Index_Delete {
       /**
        * @param args
        * @描述 通过索引名删除索引
        * @author Earl
        * @version 1.0.0
        * @创建日期 2024/01/23
        * @since 1.0.0
        */
       public static void main(String[] args) throws Exception {
   
           RestHighLevelClient esClient = new RestHighLevelClient(
                   RestClient.builder(new HttpHost("localhost", 9200, "http"))
           );
   
           // 查询索引
           DeleteIndexRequest request = new DeleteIndexRequest("user");
   
           AcknowledgedResponse response = esClient.indices().delete(request, RequestOptions.DEFAULT);
   
           // 响应状态
           System.out.println(response.isAcknowledged());
           System.out.println(response);
   
           esClient.close();
       }
   }
   

6. 新增文档

   xxxxxxxxxx
   public class ESTest05_Doc_Insert {
       /**
        * @param args
        * @描述 向索引中插入文档数据
        * @author Earl
        * @version 1.0.0
        * @创建日期 2024/01/23
        * @since 1.0.0
        */
       public static void main(String[] args) throws Exception {
   
           RestHighLevelClient esClient = new RestHighLevelClient(
                   RestClient.builder(new HttpHost("localhost", 9200, "http"))
           );
   
           // 插入数据
           IndexRequest request = new IndexRequest();
           request.index("user").id("1001");
   
           User user = new User();
           user.setName("zhangsan");
           user.setAge(30);
           user.setSex("男");
   
           // 向ES插入数据，必须将数据转换位JSON格式，这里将对象转成json用的是jackson-databind的ObjectMapper的writeValueAsString方法
           ObjectMapper mapper = new ObjectMapper();
           String userJson = mapper.writeValueAsString(user);
           //声明数据内容的类型是JSON
           request.source(userJson, XContentType.JSON);
   
           IndexResponse response = esClient.index(request, RequestOptions.DEFAULT);
   
           System.out.println(response.getResult());
   
           esClient.close();
       }
   }
   

7. 修改文档

   xxxxxxxxxx
   public class ESTest06_Doc_Update {
       public static void main(String[] args) throws Exception {
   
           RestHighLevelClient esClient = new RestHighLevelClient(
                   RestClient.builder(new HttpHost("localhost", 9200, "http"))
           );
   
           // 修改数据
           UpdateRequest request = new UpdateRequest();
           request.index("user").id("1001");
           request.doc(XContentType.JSON, "sex", "女");
   
           UpdateResponse response = esClient.update(request, RequestOptions.DEFAULT);
   
           System.out.println(response.getResult());
   
           esClient.close();
       }
   }
   

8. 查询文档

   xxxxxxxxxx
   public class ESTest07_Doc_Get {
       public static void main(String[] args) throws Exception {
   
           RestHighLevelClient esClient = new RestHighLevelClient(
                   RestClient.builder(new HttpHost("localhost", 9200, "http"))
           );
   
           // 查询数据
           GetRequest request = new GetRequest();
           request.index("user").id("1001");
           GetResponse response = esClient.get(request, RequestOptions.DEFAULT);
   
           System.out.println(response.getSourceAsString());
   
           esClient.close();
       }
   }
   

9. 删除文档

   xxxxxxxxxx
   public class ESTest08_Doc_Delete {
       public static void main(String[] args) throws Exception {
   
           RestHighLevelClient esClient = new RestHighLevelClient(
                   RestClient.builder(new HttpHost("localhost", 9200, "http"))
           );
   
   
           DeleteRequest request = new DeleteRequest();
           request.index("user").id("1001");
   
           DeleteResponse response = esClient.delete(request, RequestOptions.DEFAULT);
           System.out.println(response.toString());
   
           esClient.close();
       }
   }
   

10. 批量新增文档

    xxxxxxxxxx
    public class ESTest09_Doc_Insert_Batch {
        public static void main(String[] args) throws Exception {
    
            RestHighLevelClient esClient = new RestHighLevelClient(
                    RestClient.builder(new HttpHost("localhost", 9200, "http"))
            );
    
            // 批量插入数据
            BulkRequest request = new BulkRequest();
    
            request.add(new IndexRequest().index("user").id("1001").source(XContentType.JSON, "name", "zhangsan", "age",30,"sex","男"));
            request.add(new IndexRequest().index("user").id("1002").source(XContentType.JSON, "name", "lisi", "age",30,"sex","女"));
            request.add(new IndexRequest().index("user").id("1003").source(XContentType.JSON, "name", "wangwu", "age",40,"sex","男"));
            request.add(new IndexRequest().index("user").id("1004").source(XContentType.JSON, "name", "wangwu1", "age",40,"sex","女"));
            request.add(new IndexRequest().index("user").id("1005").source(XContentType.JSON, "name", "wangwu2", "age",50,"sex","男"));
            request.add(new IndexRequest().index("user").id("1006").source(XContentType.JSON, "name", "wangwu3", "age",50,"sex","男"));
            request.add(new IndexRequest().index("user").id("1007").source(XContentType.JSON, "name", "wangwu44", "age",60,"sex","男"));
            request.add(new IndexRequest().index("user").id("1008").source(XContentType.JSON, "name", "wangwu555", "age",60,"sex","男"));
            request.add(new IndexRequest().index("user").id("1009").source(XContentType.JSON, "name", "wangwu66666", "age",60,"sex","男"));
            request.add(new IndexRequest().index("user").id("1010").source(XContentType.JSON, "name", "赵六", "age",60,"sex","男"));
            request.add(new IndexRequest().index("user").id("1011").source(XContentType.JSON, "name", "赵七", "age",60,"sex","男"));
            request.add(new IndexRequest().index("user").id("1012").source(XContentType.JSON, "name", "赵八", "age",60,"sex","男"));
            request.add(new IndexRequest().index("user").id("1013").source(XContentType.JSON, "name", "小六", "age",60,"sex","男"));
            request.add(new IndexRequest().index("user").id("1014").source(XContentType.JSON, "name", "小七", "age",60,"sex","男"));
            request.add(new IndexRequest().index("user").id("1015").source(XContentType.JSON, "name", "小八", "age",60,"sex","男"));
            request.add(new IndexRequest().index("user").id("1016").source(XContentType.JSON, "name", "wang1wu", "age",60,"sex","男"));
            request.add(new IndexRequest().index("user").id("1017").source(XContentType.JSON, "name", "wa1ng2wu", "age",60,"sex","男"));
    
            BulkResponse response = esClient.bulk(request, RequestOptions.DEFAULT);
            System.out.println(response.getTook());
            System.out.println(response.getItems());
    
            esClient.close();
        }
    }
    

11. 批量删除文档

    xxxxxxxxxx
    public class ESTest10_Doc_Delete_Batch {
        public static void main(String[] args) throws Exception {
    
            RestHighLevelClient esClient = new RestHighLevelClient(
                    RestClient.builder(new HttpHost("localhost", 9200, "http"))
            );
    
            // 批量删除数据
            BulkRequest request = new BulkRequest();
    
            request.add(new DeleteRequest().index("user").id("1001"));
            request.add(new DeleteRequest().index("user").id("1002"));
            request.add(new DeleteRequest().index("user").id("1003"));
            request.add(new DeleteRequest().index("user").id("1004"));
            request.add(new DeleteRequest().index("user").id("1005"));
            request.add(new DeleteRequest().index("user").id("1006"));
            request.add(new DeleteRequest().index("user").id("1007"));
            request.add(new DeleteRequest().index("user").id("1008"));
            request.add(new DeleteRequest().index("user").id("1009"));
    
            BulkResponse response = esClient.bulk(request, RequestOptions.DEFAULT);
            System.out.println(response.getTook());
            System.out.println(response.getItems());
    
            esClient.close();
        }
    }
    

12. 高级查询API

    xxxxxxxxxx
    public class ESTest11_Doc_Query {
        public static void main(String[] args) throws Exception {
    
            RestHighLevelClient esClient = new RestHighLevelClient(
                    RestClient.builder(new HttpHost("localhost", 9200, "http"))
            );
    
            // 1. 查询索引中全部的数据
            /*SearchRequest request = new SearchRequest();
            request.indices("user");
    
            //构造查询条件，这是查询一个索引下的所有
            request.source(new SearchSourceBuilder().query(QueryBuilders.matchAllQuery()));
    
            SearchResponse response = esClient.search(request, RequestOptions.DEFAULT);
    
            SearchHits hits = response.getHits();
    
            System.out.println(hits.getTotalHits());
            System.out.println(response.getTook());
    
            for ( SearchHit hit : hits ) {
                System.out.println(hit.getSourceAsString());
            }*/
    
            // 2. 条件查询 : termQuery，按字段精确匹配查询
            /*SearchRequest request = new SearchRequest();
            request.indices("user");
    
            request.source(new SearchSourceBuilder().query(QueryBuilders.termQuery("age", 30)));
            SearchResponse response = esClient.search(request, RequestOptions.DEFAULT);
    
            SearchHits hits = response.getHits();
    
            System.out.println(hits.getTotalHits());
            System.out.println(response.getTook());
    
            for ( SearchHit hit : hits ) {
                System.out.println(hit.getSourceAsString());
            }*/
    
            // 3. 分页查询
            /*SearchRequest request = new SearchRequest();
            request.indices("user");
    
            SearchSourceBuilder builder = new SearchSourceBuilder().query(QueryBuilders.matchAllQuery());
            // from中是(当前页码-1)*每页显示数据条数
            builder.from(2);
            builder.size(2);
            request.source(builder);
            SearchResponse response = esClient.search(request, RequestOptions.DEFAULT);
    
            SearchHits hits = response.getHits();
    
            System.out.println(hits.getTotalHits());
            System.out.println(response.getTook());
    
            for ( SearchHit hit : hits ) {
                System.out.println(hit.getSourceAsString());
            }*/
    
            // 4. 查询排序
            /*SearchRequest request = new SearchRequest();
            request.indices("user");
    
            SearchSourceBuilder builder = new SearchSourceBuilder().query(QueryBuilders.matchAllQuery());
            //对查询结果按照年龄进行升序
            builder.sort("age", SortOrder.DESC);
    
            request.source(builder);
            SearchResponse response = esClient.search(request, RequestOptions.DEFAULT);
    
            SearchHits hits = response.getHits();
    
            System.out.println(hits.getTotalHits());
            System.out.println(response.getTook());
    
            for ( SearchHit hit : hits ) {
                System.out.println(hit.getSourceAsString());
            }*/
    
            // 5. 过滤字段
            /*SearchRequest request = new SearchRequest();
            request.indices("user");
    
            SearchSourceBuilder builder = new SearchSourceBuilder().query(QueryBuilders.matchAllQuery());
    
            String[] excludes = {"age","sex"};
            String[] includes = {};
            //includes和excludes是包含和排除哪些字段,是两个数组
            builder.fetchSource(includes, excludes);
    
            request.source(builder);
            SearchResponse response = esClient.search(request, RequestOptions.DEFAULT);
    
            SearchHits hits = response.getHits();
    
            System.out.println(hits.getTotalHits());
            System.out.println(response.getTook());
    
            for ( SearchHit hit : hits ) {
                System.out.println(hit.getSourceAsString());
            }*/
    
            // 6. 组合查询
            /*SearchRequest request = new SearchRequest();
            request.indices("user");
    
            SearchSourceBuilder builder = new SearchSourceBuilder();
            BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
    
            //boolQueryBuilder.must(QueryBuilders.matchQuery("age", 30));
            //boolQueryBuilder.must(QueryBuilders.matchQuery("sex", "男"));
            //还可以用不是什么mustNot
            //boolQueryBuilder.mustNot(QueryBuilders.matchQuery("sex", "男"));
            //boolQueryBuilder.should(QueryBuilders.matchQuery("age", 30));
            //boolQueryBuilder.should(QueryBuilders.matchQuery("age", 40));
            //注意分词查询只能是中文的情况，英文输入QueryBuilders.matchQuery("name", "wang")查询到的数据是0，must是同时满足；should是满足其中一个
            boolQueryBuilder.should(QueryBuilders.matchQuery("name", "小赵"));//中文小开头的和赵开头的都能查到，貌似只有中文能分词
    
            builder.query(boolQueryBuilder);
    
            request.source(builder);
            SearchResponse response = esClient.search(request, RequestOptions.DEFAULT);
    
            SearchHits hits = response.getHits();
    
            System.out.println(hits.getTotalHits());
            System.out.println(response.getTook());
    
            for ( SearchHit hit : hits ) {
                System.out.println(hit.getSourceAsString());
            }*/
    
            // 7. 范围查询
            /*SearchRequest request = new SearchRequest();
            request.indices("user");
    
            SearchSourceBuilder builder = new SearchSourceBuilder();
            //对某个字段获取查询范围对象
            RangeQueryBuilder rangeQuery = QueryBuilders.rangeQuery("age");
    
            //大于30，小于50
            rangeQuery.gte(30);
            rangeQuery.lt(50);
    
            builder.query(rangeQuery);
    
            request.source(builder);
            SearchResponse response = esClient.search(request, RequestOptions.DEFAULT);
    
            SearchHits hits = response.getHits();
    
            System.out.println(hits.getTotalHits());
            System.out.println(response.getTook());
    
            for ( SearchHit hit : hits ) {
                System.out.println(hit.getSourceAsString());
            }*/
    
            // 8. 模糊查询
            /*SearchRequest request = new SearchRequest();
            request.indices("user");
    
            SearchSourceBuilder builder = new SearchSourceBuilder();
            //匹配name字段为字符串wangwu，fuzziness(Fuzziness.TWO))是允许有两个字符不匹配，就是整个name属性能去掉任意两个以下字符匹配上wangwu就能被查询出来
            //builder.query(QueryBuilders.fuzzyQuery("name", "wangwu").fuzziness(Fuzziness.TWO));
            //中文也是可以的
            builder.query(QueryBuilders.fuzzyQuery("name", "六").fuzziness(Fuzziness.TWO));
    
            request.source(builder);
            SearchResponse response = esClient.search(request, RequestOptions.DEFAULT);
    
            SearchHits hits = response.getHits();
    
            System.out.println(hits.getTotalHits());
            System.out.println(response.getTook());
    
            for ( SearchHit hit : hits ) {
                System.out.println(hit.getSourceAsString());
            }*/
    
            // 9. 高亮查询
            /*SearchRequest request = new SearchRequest();
            request.indices("user");
    
            SearchSourceBuilder builder = new SearchSourceBuilder();
            TermsQueryBuilder termsQueryBuilder = QueryBuilders.termsQuery("name.keyword", "小六");
            //TermsQueryBuilder termsQueryBuilder = QueryBuilders.termsQuery("name.keyword", "zhangsan");
    
            HighlightBuilder highlightBuilder = new HighlightBuilder();
            highlightBuilder.preTags("<font color='red'>");
            highlightBuilder.postTags("</font>");
            //对查询结果的name字段做高亮显示
            highlightBuilder.field("name");
    
            builder.highlighter(highlightBuilder);
            builder.query(termsQueryBuilder);
    
            request.source(builder);
            SearchResponse response = esClient.search(request, RequestOptions.DEFAULT);
    
            SearchHits hits = response.getHits();
    
            System.out.println(hits.getTotalHits());
            System.out.println(response.getTook());
            System.out.println(response);
    
            for ( SearchHit hit : hits ) {
                System.out.println(hit.getSourceAsString());
                //highlight标签在hits.hits属性中，是其子属性，同时response重写了toString方法，可以直接显示其中的属性值和结构
                //注意这里查匹配到对应字段为中文，需要使用 QueryBuilders.termsQuery("name.keyword", "小六");才能查询出来，否则查不来对应字
                // 段是中文的，且就算查出来，hits.hits中也没有高亮属性
                System.out.println(hit.getHighlightFields());
            }*/
    
            // 10. 聚合查询
            /*SearchRequest request = new SearchRequest();
            request.indices("user");
    
            SearchSourceBuilder builder = new SearchSourceBuilder();
    
            //maxAge会显示在响应的数据中作为对age字段求最大值后的属性名
            AggregationBuilder aggregationBuilder = AggregationBuilders.max("maxAge").field("age");
            builder.aggregation(aggregationBuilder);
    
            request.source(builder);
            SearchResponse response = esClient.search(request, RequestOptions.DEFAULT);
    
            SearchHits hits = response.getHits();
    
            System.out.println(hits.getTotalHits());
            System.out.println(response.getTook());
            System.out.println(response);
    
            for ( SearchHit hit : hits ) {
                System.out.println(hit.getSourceAsString());
            }*/
    
            // 11. 分组查询
            SearchRequest request = new SearchRequest();
            request.indices("user");
    
            SearchSourceBuilder builder = new SearchSourceBuilder();
    
            AggregationBuilder aggregationBuilder = AggregationBuilders.terms("ageGroup").field("age");
            builder.aggregation(aggregationBuilder);
    
            request.source(builder);
            SearchResponse response = esClient.search(request, RequestOptions.DEFAULT);
            SearchHits hits = response.getHits();
    
            System.out.println(hits.getTotalHits());
            System.out.println(response.getTook());
            System.out.println(response);
    
            for ( SearchHit hit : hits ) {
                System.out.println(hit.getSourceAsString());
            }
            esClient.close();
        }
    }
    

13. 查询指定索引下的全部文档

    xxxxxxxxxx
    public class ESTest12_Doc_Search {
        public static void main(String[] args) throws Exception {
    
            RestHighLevelClient esClient = new RestHighLevelClient(
                    RestClient.builder(new HttpHost("localhost", 9200, "http"))
            );
    
            // 1. 查询索引的所有数据
            SearchRequest request = new SearchRequest();
            request.indices("user");
    
            // 构造查询条件
            SearchSourceBuilder builder = new SearchSourceBuilder();
            builder.query(QueryBuilders.matchAllQuery());
    
            request.source(builder);
    
            SearchResponse response = esClient.search(request, RequestOptions.DEFAULT);
    
            SearchHits hits = response.getHits();
    
            System.out.println(response.getTook());
            System.out.println(hits.getTotalHits());
            Iterator<SearchHit> iterator = hits.iterator();
            while (iterator.hasNext()) {
                SearchHit hit = iterator.next();
                System.out.println(hit.getSourceAsString());
            }
    
            esClient.close();
        }
    }
    

     

RESTFUL简介

RESTful的REST是Representational State Transfer的开头，表示请求资源状态转换

1. 简介

   • 缩写：REST【不是"rest"这个单词】

   • 外文名：Representational State Transfer，简称REST，

     • Resource：资源，即数据（这是网络的核心）

     • Representational：某种表现形式，比如用JSON，XML，JPEG等

     • State Transfer：状态变化。通过HTTP的动词（get查询、post新增、put修改、delete删除）实现

   • 中文名：表现层状态转移

   • 提出时间：2000年

   • 属性：一种软件架构风格【以Web为平台的。web服务的架构风格，前后端接口时候用到】，是一种组织Web服务的架构，不是一种技术也不是一种标准，作为一种架构，其提出了一系列架构级约束

2. Rest架构的五条约束

   一个系统满足了上面所列出的五条约束，那么该系统就被称为是RESTful的

   • 使用客户/服务器(b/s、 c/s)模型。客户和服务器之间通过一个统一的接口来互相通讯。

   • 层次化的系统。在一个REST系统中，客户端并不会固定地与一个服务器打交道。

   • 无状态。在一个REST系统中，服务端并不会保存有关客户的任何状态。也就是说，客户端自身负责用户状态的维持，并在每次发送请求时都需要提供足够的信息。

   • 可缓存。REST系统需要能够恰当地缓存请求，以尽量减少服务端和客户端之间的信息传输，以提高性能。

   • 统一的接口。一个REST系统需要使用一个统一的接口来完成子系统之间以及服务与用户之间的交互。这使得REST系统中的各个子系统可以独自完成演化。【无论什么样的资源都应该使用相同的相同的接口对资源进行访问，使用HTTP协议提供的标准请求方式对资源进行操作；即对同一资源的访问都使用相同的URI，URI管理资源的定位；使用不同的方法来对同一个资源进行不同的操作，幂等性，后续无论多少次GET、PUT、DELETE、HEAD请求都是幂等性的，无论后续发起多少次相同的请求都不会对数据产生更多的影响，但是POST请求就不是幂等性的了】

3. Rest架构的优点

   URI：统一资源路径，作为资源的唯一标识

   • 适合做前后端分离项目

   • 前端拿到数据只负责展示和渲染，不对数据做任何处理。后端处理数据并以JSON格式传输出去，定义这样一套统一的接口，在web，ios，android三端都可以用相同的接口，RESTFUL让后端接口实现天然的跨平台【因为不需要写三次代码，一次代码可以公用给三端；另外，修改代码只要修改一次，三端都同步访问新代码，不需要修改三次代码】

集群配置

windows环境

1. 清空根目录下的data文件目录和logs目录下的所有文件

   • 因为以前可能使用过该软件，导致有数据

   • 直接删掉整个data文件夹

   • 保留logs目录，清空logs目录下的所有的文件

2. 在config/ealsticsearch.yml对集群环境的第一个节点进行配置

   • 默认配置全是注释，集群环境下需要对以下指定选项进行配置

   • 集群名称cluster.name: my-application，多个EalsticSearch节点的集群名称必须相同

   • 当前节点的名字node.name: node-1，同一个EalsticSearch集群每个节点的名字不能重复

   • 主机名称network.host: localhost，当前节点所在的主机的IP

   • Http端口号http.port: 1001

   • TCP通信监听端口号transport.tcp.port: 9301

   • 指定当前节点是master节点和数据节点

     xxxxxxxxxx
     node.master: true
     node.data: true
     

   • 跨域配置

     xxxxxxxxxx
     http.cors.enabled: true
     http.cors.allow-origin: "*"
     

   • 双击/bin/elasticsearch.bat启动该节点

     启动以后能看到以下控制台日志说明启动成功，不成功可能是端口号占用，端口排查和杀掉进程查看【工具目录下的windows指南】

     xxxxxxxxxx
     [2024-04-13T17:59:19,809][INFO ][o.e.n.Node               ] [node-1] node name [node-1], node ID [7aDVXWxuRMirgLOTBBgUPw], cluster name [my-application]
     

   • 使用PostMan发送请求http://localhost:1004/_cluster/health【GET】检查集群中某个节点和整个集群的状态

     • 请求任意一台节点的HTTP端口都行，都会显示当前节点的状态信息和集群信息

     • 响应内容

       注意，更改了ES集群中某个节点的配置文件【端口号】，需要将ES文件的数据目录删掉，否则查询集群健康状态会报错error并响应状态码503

       • "status": "green",表示集群状态正常

       • "number_of_nodes": 1,表示当前集群节点数量为1

       • "number_of_data_nodes": 1,表示当前数据节点数量为1

       xxxxxxxxxx
       {
           "cluster_name": "my-application",
           "status": "green",
           "timed_out": false,
           "number_of_nodes": 1,
           "number_of_data_nodes": 1,
           "active_primary_shards": 0,
           "active_shards": 0,
           "relocating_shards": 0,
           "initializing_shards": 0,
           "unassigned_shards": 0,
           "delayed_unassigned_shards": 0,
           "number_of_pending_tasks": 0,
           "number_of_in_flight_fetch": 0,
           "task_max_waiting_in_queue_millis": 0,
           "active_shards_percent_as_number": 100.0
       }
       

3. 配置集群其他节点

   • 将第一个节点的整个ES拷贝一份新的，将data目录删掉，logs目录下的所有文件全部删掉

   • 更改config/elasticsearch.yml中的节点名称、Http端口号、TCP通信监听端口号

   • 在后续节点config/elasticsearch.yml添加以下配置

     ES的单个节点不知道其他节点的具体位置，需要使用下列配置对ES进行告知，这是ES中查找节点的模块；第一台机器【还是master机器不用加？】不需要添加该配置【注意此时第二个节点的配置中仍然还是node.master: true】，该配置是让其他节点去找第一台机器

     • discovery.seed_hosts: ["localhost:9301"]是去查找第一台节点的集群内部通信端口

       xxxxxxxxxx
       discovery.seed_hosts: ["localhost:9301"]
       discovery.zen.fd.ping_timeout: 1m
       discovery.zen.fd.ping_retries: 5
       

     • 同样的方式启动节点2，用PostMan发送请求http://localhost:1004/_cluster/health【GET】访问集群状态

       注意一旦更改过第一个节点的配置【端口】，其他节点的data文件夹就需要删掉，否则其他节点启动也会报错，节点新建的时候拷贝的副本也需要删掉data目录，

     • 第三台机器启动的时候既可以查找第一台机器的9301端口，也可以查找第二台机器的9302端口，所以节点发现的主机端口是一个数组，由已经运行的可供当前节点发现集群的任意一台节点端口组成【？疑问，为什么不将所有节点的该属性设置为其他节点】

4. 常见问题

   • 以上配置在一次启动以后如果发生中途master节点变更以后第二次就启动不了的情况，使用请求http://127.0.0.1:1004/_cluster/health【GET】报错如下：

     删除data目录和日志也启动不了且报错相同，这里有可能是节点状态发生变更后发生的错误，很大原因可能是删除了data目录导致启动以后找不到master节点，或者也可能添加了第三方的分析器；但是无论如何，添加下面的配置cluster.initial_master_nodes: node-1不会出问题，而且再次启动集群不需要删除data目录，master节点状态也时正常的

     xxxxxxxxxx
     {
         "error": {
             "root_cause": [
                 {
                     "type": "master_not_discovered_exception",
                     "reason": null
                 }
             ],
             "type": "master_not_discovered_exception",
             "reason": null
         },
         "status": 503
     }
     

     • 需要在每个节点配置文件添加以下配置重启所有ES节点即可

       这种方式不会影响master节点重选宕机节点重启以后的master节点，仍然遵循下次master节点故障后再重选的原则

       xxxxxxxxxx
       cluster.initial_master_nodes: node-1
       

        

Linux环境

安装ElasticSearch

安装步骤

1. 从地址https://www.elastic.co/cn/downloads/past-releases/elasticsearch-7-8-0选中LINUX_X86_64 sha下载指定版本的Linux版本的ES压缩包elasticsearch-7.8.0-linux-x86_64.tar.gz并上传至Linux系统

2. 在上传目录使用命令tar -zxvf elasticsearch-7.8.0-linux-x86_64.tar.gz解压缩压缩包，解压后的名字较长，使用命令mv elasticsearch-7.8.0 es-7.8.0将ES的名字修改为es-7.8.0

3. 使用root用户创建新用户来使用es

   • 出于安全问题，ES不允许root用户直接运行，需要在root用户中创建新的用户

   • 使用命令useradd es为linux系统创建es用户

   • 使用命令passwd es在弹窗界面为es用户设置密码

   • 如果用户创建错误可以使用命令userdel -r es删除用户es

   • 使用命令chown -R es:es /opt/elasticsearch/es-7.8.0设置es用户为es解压文件的所有者

4. 修改根目录下的配置文件/config/elasticsearch.yml，添加以下配置

   xxxxxxxxxx
   # 加入如下配置
   # 设置集群名称为elasticsearch，默认就叫elasticsearch
   cluster.name: elasticsearch
   # 设置节点名称为node-1
   node.name: node-1
   # 不用管，按样子配置，这个没讲
   network.host: 0.0.0.0
   #配置HTTP端口号为9200
   http.port: 9200
   # 将当前节点作为master节点，中括号中的名称要和当前节点的名称保持一致
   cluster.initial_master_nodes: ["node-1"]
   

5. 修改Linux系统配置文件

   ES生成的数据和文件比较多，生成文件时使用系统默认配置可能会出一些问题，需要对系统的配置进行修改

   • 使用vim /etc/security/limits.conf修改文件/etc/security/limits.conf，在文件末尾添加每个进程可以打开的文件数的限制的以下配置

     xxxxxxxxxx
     # 在文件末尾中增加下面内容
     # 每个进程可以打开的文件数的限制
     es soft nofile 65536
     es hard nofile 65536
     

   • 使用命令vim /etc/security/limits.d/20-nproc.conf修改系统配置文件，在文件末尾添加以下配置

     xxxxxxxxxx
     # 在文件末尾中增加下面内容
     # 每个进程可以打开的文件数的限制
     es soft nofile 65536
     es hard nofile 65536
     # 操作系统级别对每个用户创建的进程数的限制
     * hard nproc 4096
     # 注： * 带表 Linux 所有用户名称
     

   • 使用命令vim /etc/sysctl.conf在文件末尾追加配置一个进程可以拥有的虚拟内存的数量

     xxxxxxxxxx
     # 在文件中增加下面内容
     # 一个进程可以拥有的 VMA(虚拟内存区域)的数量,默认值为 65536
     vm.max_map_count=655360
     

   • 使用命令sysctl -p重新加载系统配置

6. 启动ES

   • 不能直接进入es根目录使用命令bin/elasticsearch运行程序，会直接报错，因为不允许使用root用户运行程序，要使用命令su es将当前系统用户切换成es【或者自定义用户】再使用命令bin/elasticsearch来运行程序，此时如果之前没有设置chown -R es:es /opt/elasticsearch/es-7.8.0用户权限，此时启动创建文件会出现问题

安装成功测试

1. 正常启动的效果和windows是一样的，只要出现控制台日志[2024-04-13T17:59:19,809][INFO ][o.e.n.Node] [node-1] node name [node-1], node ID [7aDVXWxuRMirgLOTBBgUPw], cluster name [my-application]没有报错就是正常启动了，更准确的测试是像服务器发送请求http://192.168.200.136:9200/_cluster/health查询节点状态并响应如下内容

   注意这一步发送请求需要关闭防火墙或者放开对应的端口

   xxxxxxxxxx
   {
       "cluster_name": "elasticsearch",
       "status": "green",
       "timed_out": false,
       "number_of_nodes": 1,
       "number_of_data_nodes": 1,
       "active_primary_shards": 0,
       "active_shards": 0,
       "relocating_shards": 0,
       "initializing_shards": 0,
       "unassigned_shards": 0,
       "delayed_unassigned_shards": 0,
       "number_of_pending_tasks": 0,
       "number_of_in_flight_fetch": 0,
       "task_max_waiting_in_queue_millis": 0,
       "active_shards_percent_as_number": 100.0
   }
   

集群部署

1. 从地址https://www.elastic.co/cn/downloads/past-releases/elasticsearch-7-8-0选中LINUX_X86_64 sha下载指定版本的Linux版本的ES压缩包elasticsearch-7.8.0-linux-x86_64.tar.gz并上传至Linux系统

2. 在上传目录使用命令tar -zxvf elasticsearch-7.8.0-linux-x86_64.tar.gz解压缩压缩包，解压后的名字较长，使用命令mv elasticsearch-7.8.0 es-7.8.0-cluster将ES的名字修改为es-7.8.0-cluster

3. 在虚拟机ip分别为131和135的机器上再重复解压安装一遍，实际上可以使用命令进行其他机器的文件分发，这个在尚硅谷的Hadoop课程中有讲文件分发，后续补充，这里先试用手动解压的方式安装

4. 为所有es创建操作用户，赋予操作用户对应文件目录的权限，自定义三台主机的主机名

   自定义主机名的方法见本文档命令大全中系统操作中的主机名，三台机器136、131、135对应的主机名分别为elasticsearch1、nginx1和elasticsearch3

5. 修改136机器上的配置文件/opt/elasticsearch/es-7.8.0-cluster/config/elasticsearch.yml

   • 136的配置文件

     初始默认配置文件全是注释，直接在文件末尾添加以下配置即可

     xxxxxxxxxx
     # 加入如下配置
     #集群名称
     cluster.name: cluster-es
     #节点名称， 每个节点的名称不能重复
     node.name: node-1
     #ip 地址， 每个节点的地址不能重复
     network.host: elasticsearch1
     #是不是有资格主节点
     node.master: true
     node.data: true
     http.port: 9200
     # head 插件需要这打开这两个配置
     http.cors.allow-origin: "*"
     http.cors.enabled: true
     http.max_content_length: 200mb
     #es7.x 之后新增的配置，初始化一个新的集群时需要此配置来选举 master
     cluster.initial_master_nodes: ["node-1"]
     #es7.x 之后新增的配置，节点发现，9300是es内部节点默认的通信地址
     discovery.seed_hosts: ["elasticsearch1:9300","nginx1:9300","elasticsearch3:9300"]
     gateway.recover_after_nodes: 2
     network.tcp.keep_alive: true
     network.tcp.no_delay: true
     transport.tcp.compress: true
     #集群内同时启动的数据任务个数，默认是 2 个
     cluster.routing.allocation.cluster_concurrent_rebalance: 16
     #添加或删除节点及负载均衡时并发恢复的线程个数，默认 4 个
     cluster.routing.allocation.node_concurrent_recoveries: 16
     #初始化数据恢复时，并发恢复线程的个数，默认 4 个
     cluster.routing.allocation.node_initial_primaries_recoveries: 16
     

   • 131的配置文件

     相比于136只是修改了节点名称和主机名称

     xxxxxxxxxx
     # 加入如下配置
     #集群名称
     cluster.name: cluster-es
     #节点名称， 每个节点的名称不能重复
     node.name: node-2
     #ip 地址， 每个节点的地址不能重复
     network.host: nginx1
     #是不是有资格主节点
     node.master: true
     node.data: true
     http.port: 9200
     # head 插件需要这打开这两个配置
     http.cors.allow-origin: "*"
     http.cors.enabled: true
     http.max_content_length: 200mb
     #es7.x 之后新增的配置，初始化一个新的集群时需要此配置来选举 master
     cluster.initial_master_nodes: ["node-1"]
     #es7.x 之后新增的配置，节点发现，9300是es内部节点默认的通信地址
     discovery.seed_hosts: ["elasticsearch1:9300","nginx1:9300","elasticsearch3:9300"]
     gateway.recover_after_nodes: 2
     network.tcp.keep_alive: true
     network.tcp.no_delay: true
     transport.tcp.compress: true
     #集群内同时启动的数据任务个数，默认是 2 个
     cluster.routing.allocation.cluster_concurrent_rebalance: 16
     #添加或删除节点及负载均衡时并发恢复的线程个数，默认 4 个
     cluster.routing.allocation.node_concurrent_recoveries: 16
     #初始化数据恢复时，并发恢复线程的个数，默认 4 个
     cluster.routing.allocation.node_initial_primaries_recoveries: 16
     

   • 135的配置

     同样相比于136只是修改了节点名称和主机名称

     xxxxxxxxxx
     # 加入如下配置
     #集群名称
     cluster.name: cluster-es
     #节点名称， 每个节点的名称不能重复
     node.name: node-3
     #ip 地址， 每个节点的地址不能重复
     network.host: elasticsearch3
     #是不是有资格主节点
     node.master: true
     node.data: true
     http.port: 9200
     # head 插件需要这打开这两个配置
     http.cors.allow-origin: "*"
     http.cors.enabled: true
     http.max_content_length: 200mb
     #es7.x 之后新增的配置，初始化一个新的集群时需要此配置来选举 master
     cluster.initial_master_nodes: ["node-1"]
     #es7.x 之后新增的配置，节点发现，9300是es内部节点默认的通信地址
     discovery.seed_hosts: ["elasticsearch1:9300","nginx1:9300","elasticsearch3:9300"]
     gateway.recover_after_nodes: 2
     network.tcp.keep_alive: true
     network.tcp.no_delay: true
     transport.tcp.compress: true
     #集群内同时启动的数据任务个数，默认是 2 个
     cluster.routing.allocation.cluster_concurrent_rebalance: 16
     #添加或删除节点及负载均衡时并发恢复的线程个数，默认 4 个
     cluster.routing.allocation.node_concurrent_recoveries: 16
     #初始化数据恢复时，并发恢复线程的个数，默认 4 个
     cluster.routing.allocation.node_initial_primaries_recoveries: 16
     

6. 每台主机都修改对应的系统配置文件

   ES生成的数据和文件比较多，生成文件时使用系统默认配置可能会出一些问题，需要对系统的配置进行修改

   • 使用vim /etc/security/limits.conf修改文件/etc/security/limits.conf，在文件末尾添加每个进程可以打开的文件数的限制的以下配置

     xxxxxxxxxx
     # 在文件末尾中增加下面内容
     # 每个进程可以打开的文件数的限制
     es soft nofile 65536
     es hard nofile 65536
     

   • 使用命令vim /etc/security/limits.d/20-nproc.conf修改系统配置文件，在文件末尾添加以下配置

     xxxxxxxxxx
     # 在文件末尾中增加下面内容
     # 每个进程可以打开的文件数的限制
     es soft nofile 65536
     es hard nofile 65536
     # 操作系统级别对每个用户创建的进程数的限制
     * hard nproc 4096
     # 注： * 带表 Linux 所有用户名称
     

   • 使用命令vim /etc/sysctl.conf在文件末尾追加配置一个进程可以拥有的虚拟内存的数量

     xxxxxxxxxx
     # 在文件中增加下面内容
     # 一个进程可以拥有的 VMA(虚拟内存区域)的数量,默认值为 65536
     vm.max_map_count=655360
     

   • 使用命令sysctl -p重新加载系统配置

7. 修改每个节点所在主机的/etc/hosts文件

   这个必须把集群节点所在的所有主机名和ip的映射关系在每一台主机上都要全部写上，如果不写当前主机和对应的ip映射关系，ES节点中network.host写当前主机的主机名非master的ES节点会直接启动报错，提示以下信息【以前的其他软件集群部署都是在所有节点主机的/etc/hosts文件中写上包括本机在内的完整的节点映射信息】

   

   • /etc/hosts文件示例

     即每个节点所在主机的hosts中都要配置完整集群节点的主机名IP映射，如果当前主机没有配置，非masterES中的network.host使用当前主机的主机名会直接导致ES启动报错，此时把network.host配置成0.0.0.0能够正常启动，但是不建议这么做，此外一定不能在/etc/hosts中将主机名配置成127.0.0.1的映射关系，会直接导致包括master节点在内的ES服务器无法被访问【连HTTP端口也无法访问】

     xxxxxxxxxx
     [es@nginx1 es-7.8.0-cluster]$ cat /etc/hosts
     127.0.0.1   localhost localhost.localdomain localhost4 localhost4.localdomain4
     ::1         localhost localhost.localdomain localhost6 localhost6.localdomain6
     192.168.200.132 node1
     192.168.200.133 node2
     192.168.200.134 node3
     192.168.200.136 elasticsearch1
     192.168.200.135 elasticsearch3
     192.168.200.131 nginx1
     

8. 切换成对应机器分别切到操作用户按顺序启动三个节点，使用PostMan发送请求http://192.168.200.136:9200/_cat/nodes【GET】查看节点所在集群的所有节点信息

   • 当只有136节点启动时的响应结果

     xxxxxxxxxx
     172.17.0.1 28 96 2 0.06 0.07 0.06 dilmrt * node-1
     

   • 当136和131都启动时的响应结果

     xxxxxxxxxx
     192.168.200.136 55 44 0 0.21 0.12 0.08 dilmrt * node-1
     192.168.200.131 21 94 4 0.09 0.08 0.07 dilmrt - node-2
     

   • 当136、131和135都启动时的响应结果

     xxxxxxxxxx
     192.168.200.136 55 44 0 0.21 0.12 0.08 dilmrt * node-1
     192.168.200.131 21 94 4 0.09 0.08 0.07 dilmrt - node-2
     192.168.200.135 21 96 2 0.04 0.07 0.06 dilmrt - node-3
     

      

核心概念

索引

1. 概念

   • 索引就是一个拥有几分相似特征的文档的集合 ，理解成比如订单数据有共同点，这个共同点就可以作为订单数据整体的索引，索引可以更形象的类比为新华字典的索引目录，按首字母排序，同一个首字母下又按照第二个、第三个首字母依次排序，这样的设计是为了加快检索速度

2. 特征

   • 一个索引由一个名字来标识（该名字必须全部是小写字母），当我们要对这个索引中的文档进行索引、搜索、更新和删除的时 候，都要使用到这个名字

   • 在一个集群中，可以定义任意多的索引，能搜索到的数据都必须索引

   • 一个索引可以被分成多片，也可以被复制0次和多次，一旦被复制，索引就有了主分片和复制分片，分片和复制数量可以在索引创建时进行指定，索引创建后可以动态地改变索引复制的数量，但是不能改变索引分片的数量；默认情况下每个索引有一个主分片和一个复制分片，即当集群至少有两个节点时，索引会默认有一个主分片和一个完全拷贝的复制分片

类型

1. 概念

   • ES早期对应关系型数据库，把索引当成数据库、把类型当成表、把文档当成数据行；后来发现索引就可以直接关联数据，在索引和数据之间再添加一个类型来关联数据显得画蛇添足，在7.x的版本以后就完全抛弃了类型的概念

   • 早期的思路是在一个索引下定义一个或多个类型，一个类型是索引的一个逻辑上的分支，语义由用户自行定义，通常会将由一组共同字段的文档定义为一个类型

文档

1. 概念

   • 文档就是一条数据，一个文档是一个可以被索引的基础信息单元，保存一条数据就是保存一个文档

2. 特征

   • 文档以JSON的格式来表示，JSON是一种通用的互联网数据交互格式，有很多第三方类库都能解析JSON字符串

   • 在一个索引或者类型中可以存储任意数量的文档

字段

1. 概念

   • JSON格式文档中的属性就是字段，对应数据库表中字段，对文档数据可以根据不同属性进行分类标识

映射

1. 概念

   • 类比于MySQL，表结构信息规定了一张表有哪些字段，字段类型、长度范围、默认值、是否可以为null，索引也会有类似于表结构的概念，比如规定哪些字段可以被查询，哪些字段可以进行分词操作，都有专门的设定；该设定就是映射

   • 即映射是ES中数据的使用规则设置，按最优规则处理数据会极大地提高处理数据的性能

分片

1. 概念

   • 一个索引可以存储超出单个节点硬件限制的大量文档数据，比如一个含有十亿文档数据的索引可能占据1TB的磁盘空间，但是任何一个节点都没有这么大的磁盘空间；或者数据量太大，单个节点处理搜索请求响应太慢；ES针对该问题，提供将索引划分成多份的能力，每一份就是一个分片；比如把用户索引下的文档数据按照性别拆分成两个分片，查询用户数据男性去一个分片查，女性去另一个分片查

   • 创建索引时可以指定该索引想要分片的数量，每个分片本身就是一个功能完善且独立的索引，该索引可以被放置到集群中的任何节点上

2. 特征

   • 索引是分片的集合，当ES在索引中搜索的时候，会发送查询到每一个属于索引的分片上，合并每个分片的查询结果到一个全局的结果集

3. 意义

   • 分片很重要，一方面允许用户水平切割/扩展用户的内容容量，另一方面允许用户在分片上进行分布式的并行的操作，从而提高查询性能和数据的吞吐量

副本

1. 概念

   • 在网络或者云环境中，由于网络或者节点宕机导致或者任何原因导致的查询失败随时都可能发生，需要实现一种故障转移机制，让故障发生时仍然正常运行或者合理服务降级，ES允许创建分片的一份或者多份拷贝，这个拷贝叫复制分片或者副本

2. 意义

   • 复制分片也是一个重要的概念，一方面在节点/分片查询失败的情况下提供高可用性

     • 🔎这点要求复制分片不会与原/主要分片置于同一个节点上

   • 另一方面也能扩展系统的搜索量/吞吐量，因为搜索可以在所有的副本上同时进行

分配

1. 概念

   • 分配是将分片分配给某个节点的过程，包括分配主分片和复制分片，如果分配的是复制分片，该过程还有从主分片复制数据的过程，该过程是由master节点完成的

ES集群原理

系统架构

1. 概念

   • ES集群是由一个或者多个拥有相同cluster.name配置的ES节点组成， 它们共同承担数据和负载的压力。

     • 🔎当有节点加入集群中或者从集群中移除节点时，集群将会重新平均分布所有的数据。

   • 主节点通过选举节点产生，负责管理集群范围内的所有变更，例如增加、删除索引，增加、删除节点等。

     • 🔎主节点不涉及文档级别的变更和搜索等操作，即使当集群只拥有一个主节点的情况下，流量的增加也不会因为只有一个主节点而因此成为系统的瓶颈。 任何节点都可以成为主节点。

   • 用户请求可以发送到包括主节点在内的集群中的任意一个节点，任意一个节点都能将用户请求转发到存储所需文档的节点，并收集从各个包含所需文档的节点收集回数据最终返回给客户端

2. 架构图

   • 📌：Master节点上也有分片，为什么上面说master机器不涉及文档级别的变更和搜索

   • P0、P1、P2表示每个节点上的分片，R0、R1、R2表示每个分片对应的副本，分片和对应副本不能放在同一个节点上

   • 每个分片底层是一个Lucene Index，Lucene是全文检索引擎，每个分片都是一个检索引擎，查询的时候会自动将满足查询条件的多个分片数据合并在一起进行返回

     • 🔎因此文档数据的查询相对复杂一些，文档数据的新增的过程会相对更简单​

   

    

单节点集群

1. 业务需求

   • 📜：​在只包含一个空间节点的集群内创建名为users的索引，分配三个主分片和一个副本

     • 🔎：​每个主分片拥有一个副本分片

   • 💡：​启动windows集群中的一个ES节点，向HTTP端口发送请求添加索引并设置映射关系

2. 业务实现

   • 启动HTTP端口为1004的ES节点

     • 🔎：ES集群非常地坑，如果此前是三个节点的集群，此时只启动一个节点，即使是master节点也需要删除data目录，否则ES无法被访问，使用master节点也会提示master节点找不到，解决办法仅需删除data目录

   • 使用POSTMAN向节点发送请求http://127.0.0.1:1004/users【PUT】

     • 🔎：users是索引名

     • 请求体JSON

       • 🔎：设置映射参数，"number_of_shards" : 3,是设置users索引有三块分片，"number_of_replicas" : 1是复制一次

       xxxxxxxxxx
       {
           "settings" : {
               "number_of_shards" : 3,
               "number_of_replicas" : 1
           }
       }
       

3. 特点

   • 当集群是一个单节点集群时【只有一个master节点】，一个索引的三个主分片都会被分配在该一个节点上

   • 通过浏览器插件elasticsearch-head可以查看集群的状态，将插件压缩包elasticsearch-head-chrome-plugin.rar解压缩并安装到浏览器上，点开该插件输入ES的端口号点击连接

     • 集群健康值:yellow(3 of 6)表示当前集群的全部主分片都正常运行，但是副本都不正常

     • 以下三个副本都处于标灰状态，且都提示为Unassigned，即未分配状态；同一个节点既保存原始数据又保存副本是没有意义的，因为该节点发生硬件故障时，副本也是没有办法使用的；所以该状态也表示集群正常运行，但是应该故障时有丢失数据的风险

     

4. 单点故障问题

   • 集群中只有一个master节点运行时，因为没有冗余节点，一旦发生故障，数据就会有丢失的风险，此时需要再启动一个节点来做冗余

   • 启动第二个节点加入到集群，通过插件发现三个副本分片都被分配在新加节点，所有新增的被索引的文档都会保存在主分片上，然后被并行地复制到对应的副本分片

     • 📌：注意此时直接启动第二个节点会直接抛异常，因为此前的集群状态是3个节点

     • 🔑：此时需要删除第二个节点的data目录，第一个节点启动时删除data目录即可，此时第一个节点不需要做任何操作

   • 集群状态

     • 第二个节点加入集群后，3个副本分片自动分配到该节点，星号标记的节点是master节点

     • 绿色文字集群健康值: green (6 of 6)表示所有分片都正常运行，my-application是集群名字

     • 🔎：特别注意这里的3个主分片都位于同一个节点【并没有详细说明主分片在节点上的分布行为，关注一下，目前没有任何状态表明master节点上的全是主分片，课程提了一嘴主分片的边框是粗边框，这意味这三个主分片位于同一个master节点】，具体地对文档数据操作是优先使用主分片数据还是同时可以使用复制分片上的数据暂时还没有明确

     

集群水平扩容

1. 节点水平扩容

   • 双节点集群的默认行为是主分片位于master节点，复制分片位于第二个节点，当启动第三个节点加入集群，ES会为了分散负载主动对分片进行重新分配

     • 📌：第三个节点的启动同样需要删除data目录

     • 🔎：分配遵从两个原则，一是主分片和副本不能位于同一个节点，二是分片的分布应该尽量均匀，但是分片的分配还是ES集群自动决断的

   • 扩容后集群状态

     • 📌：感觉这不是很好的分配策略，为什么不是三个节点上都各分配一个主分片和一个复制分片，这不是更加合理吗？如果副本分片也可以同时进行使用，那么从节点上的分片数量上来看这种分配也合理，每个节点的硬件资源【CPU、RAM、I/O】被更少的分片共享，系统的性能会得到提升

     • 🔎：而且和课程的不一样，课程是主分片2放在了新增节点，实际测试是主分片1放在了新增节点

     

   • 副本分片可以处理数据

     • 课程后续提到，读操作的搜索和返回数据可以同时被主分片或副本分片处理，所以当你拥有越多的副本分片时，系统也将拥有越高的吞吐量，所以分片分配只需要保证主分片和复制分片不在同一个节点上，所有分片的平均分片数量保持均匀即可【增加副本只能增加读的性能，写的能力主要还是基于主分片】

2. 扩充分片数量

   • 当分片数量小于节点数时，意味着肯定有节点无法被分配分片，这种情况是不被允许的，在索引创建的时候分片数量就已经确定了，此时在不添加索引的情况下，分片数量是固定的，添加新的节点会遇到困难

   • 因为副本分片也可以同时和主分片一样用于查询操作，所以可以通过增加复制次数达到增加分片数量的目的，此时就可以继续添加新的节点来提高系统的吞吐量

   • 发送请求http://127.0.0.1:1004/users/_settings【PUT】来重新设置主分片被复制的次数

     • 请求体JSON

       xxxxxxxxxx
       {
           "number_of_replicas" : 2
       }
       

   • 集群状态

     

应对集群故障

1. 当master宕机后的集群状态

   • 此时master节点迁移到第二个节点上，主分片也被重新指定，相当于少了一份副本分片

   

2. 重启第一个节点后的集群状态

   • 第一个节点需要配置集群内其他节点的内部通信地址discovery.seed_hosts: ["localhost:9303","localhost:9302"]才能在重启以后自动发现并加入集群，注意yml的冒号后面必须有空格，否则启动报错快速失败

   • 原来的master节点被永久的重新选举，宕机的节点恢复后以全新的节点加入集群，master节点只有再次宕机后才会重新进行选举，同时主分片只有所在节点宕机后才会重新指定

   

路由计算

1. 保存数据时的路由计算

   • 当用户需要插入一条数据如zhangsan，需要先将文档数据写入对应索引下的其中一个主分片，然后再拷贝到对应的复制分片，ES集群是如何决断将该文档数据路由到哪一个主分片呢，ES集群根据自己的内部规则对文档数据进行主分片路由，这个规则就叫路由计算

   • 路由计算的规则为hash(文档数据id)%主分片数量=【0,1,2】

     • shard表示某一个分片、number_of_primary_shards表示主分片数量

     • routing表示路由参数，通过该文档可以自定义文档到分片的映射，通过自定义该路由参数可以保证相关文档如同属于一个人的文档数据都存储到一个分片中，默认是文档数据的主键id

     $$shard=hash(routing)\mathrm{\%}number\mathrm{\_}of\mathrm{\_}primary\mathrm{\_}shards$$

      

   • 示意图

     

2. 查询数据时的路由计算

   • 分片控制：用户可以访问任何一个节点来获取数据，因为存放规则是固定的，用户访问的这个节点称为协调节点

   • 一般情况下系统的分片控制规则是轮询，分片控制意思是用户访问节点的负载均衡策略，因为任意一台机器都能转发请求获取到数据，通过主键id取哈希对主分片数量取模就能得到主分片位置进而转发请求获取数据，而采用轮询的策略能够避免在用户请求层面发生流量倾斜的情况

    

写数据流程

用户请求发送给集群时并不知道数据会写到哪个分片，到达集群上某个节点后经过计算才知道数据将被写入到具体哪一个主分片

1. 新建、索引、删除文档数据的流程

   • 1️⃣：客户端发送新建、索引、删除请求到任意集群节点

     • 🔎：该节点称为协调节点

   • 2️⃣：协调节点通过路由计算将请求转换到指定主分片所在节点

   • 3️⃣：主分片将数据保存

   • 4️⃣：主分片将数据并行发送到各个副本

   • 5️⃣：副本保存后将保存结果进行反馈

     • 📌：反馈到主分片还是协调节点，暂时认为是主分片

     • 🔑：经过文档确认是反馈到主分片所在节点

   • 6️⃣：主分片将保存结果进行反馈

     • 📌：反馈给客户端还是协调节点，暂时认为是协调节点

     • 🔑：经过文档确认是反馈到协调节点

   • 7️⃣：协调节点向客户端反馈结果，客户端获取写数据反馈

2. 设置可选请求参数

   以上的流程是完整的写数据流程，一些可选的请求参数允许用户影响该流程，比如在主分片保存数据成功后就可以开始直接请求数据，因为ES的性能已经很高了，这些设置请求参数的操作很可能以数据安全为代价提升系统性能，所以这些选项实际上很少使用

   • consistency

     • 参数值: "consistency" : ["quorum"|"one"|"all"]

     • 默认值: "consistency" : "quorum"

     • 配置说明：满足指定数量活跃可用的分片副本主分片才能执行写操作

       • 🔎："consistency" : "one"：只要主分片活跃就允许执行写操作；"consistency" : "all"：必须要主分片和所有复制分片都活跃才允许执行写操作；"consistency" : "quorum"：规定数量的分片副本【分片副本包含了主分片和复制分片】活跃就允许执行写操作

       • 🔎：默认配置即"consistency" : "one"下，在仅仅视图写操作之前，主分片都要求必须有规定数量的活跃分片副本，才会执行写操作，这种设计是为了避免发生网络分区故障时进行写操作导致不同分区的数据不一致，规定数量的计算公式是

         $$int((primary+number\mathrm{\_}of\mathrm{\_}replicas)/2)+1$$

         • 🔎：number_of_replicas 指的是在索引设置中的设定副本分片数，而不是指当前处理活动状态的副本分片数，如果索引设置中规定当前索引拥有三个副本分片，规定数量为((1+2)/2)+1=3【primary暂时认为是主分片数量】,此时如果只启动两个节点，处于活跃状态的分片副本只有2，达不到规定数量，此时将无法索引和删除任何文档

       • 🔎：新索引默认有一个副本分片，在默认配置下意味着为满足规定数量需要两个活跃的分片副本，显然这种默认设置会阻止用户在单一节点上做任何事情，为了避免该问题，默认配置的规定数量计算公式只会在指定number_of_replicas副本分片数大于1的情况下才会执行

   • timeout

     • 参数值: "timeout" : 100

     • 默认值: "timeout" : 60s

     • 配置说明：没有足够副本分片的情况下Elasticsearch的最长等待时间

       • 🔎：如果没有足够的副本分片，Elasticsearch会进行等待，期望更多的分片出现

       • 🔎：默认配置下Elasticsearch最长等待一分钟，可以通过设置timeout参数来使得等待更早终止，默认单位是毫秒，即"timeout" : 100表示等待时间为100ms，也可以通过"timeout" : 30s来指定最长等待时间为30秒

      

读数据流程

1. 获取文档数据的流程

   • 1️⃣：客户端向任意一个节点发起查询请求，该节点被称为协调节点

   • 2️⃣：协调节点通过文档id计算文档数据所在的主分片和对应的全部复制分片位置

   • 3️⃣：采用轮询的负载均衡策略来轮询所有的分片副本【包含主分片和所有的副本分片】

     • 🔎：当文档被检索时，已经被索引的文档可能已经存在于主分片上但是还没有复制到副本分片上，这种情况下副本分片可能会报告文档不存在，但是主分片仍然能成功返回文档，

   • 4️⃣：分片节点将数据返回给协调分片，协调分片将结果返回给客户端

更新数据流程

1. 更新数据的流程

   

   • 1️⃣：客户端向任意一个协调节点发送更新请求

   • 2️⃣：协调节点根据文档数据的id计算主分片所在节点位置，将更新请求转发到主分片所在的节点

   • 3️⃣：主分片检索文档，修改文档内容，并尝试重新索引主分片中的文档；如果当前文档正在被另一个进程修改，当前进程无法拿到文档的锁，会一直重试步骤3，直到超过retry_on_conflict次后放弃

   • 4️⃣：如果主分片被成功更新，主分片会将新版本文档并行地转发到全部的副本分片，副本分片更新文档并重新建立索引

   • 5️⃣：一旦副本分片都返回成功，主分片节点会向协调节点返回更新成功，协调节点向客户端返回更新成功

2. 要点

   • 主分片并行将更改转发到副本分片时，不会转发更新请求，而是转发完整文档的新版本

   • 这些更改会被异步地转发到副本分片，无法保证更改请求以发送的顺序到达副本分片，如果仅仅是转发更改请求，则可能导致以错误顺序应用前后两次更改，导致文档被损坏

     • 👅：转发文档的最新版可能使用乐观锁检查记录数据的版本来避免数据的更新顺序错误，这只是本人臆测，原教学文档没有提及此事

多文档操作流程

1. 单个mget请求取回多个文档数据的步骤

   

   • 1️⃣：客户端向协调节点发送mget请求

   • 2️⃣：协调节点为涉及的每个分片构建多文档获取请求，并行地转发这些请求到主分片或者副本分片的节点上，收到这些节点的答复后，汇总这些答复构建响应并返回给客户端

     • ❓：请求主分片和副本分片的行为没有说明

     • 👅：感觉还是像单个查询请求一样在协调节点直接轮询所有的分片副本，而不是单独将请求发送给主分片，由主分片负责后续的查询工作

2. 单个批量请求bulk API中执行多个创建、索引、删除和更新请求

   

   • 1️⃣：客户端向协调节点发送bulk请求，协调节点解析请求为每个主分片所在节点创建一个批量请求，将这些批量请求并行转发到包含主分片的节点

   • 2️⃣：所有相关主分片按顺序执行每个操作，每个操作执行成功时主分片并行转发完整新文档到对应所有副本分片，然后执行下一个操作

   • 3️⃣：当所有副本分片执行成功并报告给主分片，主分片向协调节点报告执行成功，协调节点将响应收集并返回给客户端

分片原理

分片是Elasticsearch中的最小工作单元，对文档数据的检索和写操作都是基于分片完成的，一个索引的数据量太大以后会影响文档查询的效率，把一个大的索引拆成几个部分，每个部分叫一个分片；每个分片组合在一起就是一个完整的索引数据；写入完成以后分片会进行一个倒排索引的建立，在查询中使用倒排索引快速查询到文档数据；Elasticsearch底层是Lucene，Elasticsearch的倒排索引就是Lucene的倒排索引

倒排索引

1. 概念

   • 传统数据库每个字段都存储单个值，但是全文检索中文档中字段的每个词都要被搜索，对数据库来说要求单个字段具有索引多值的能力，满足一个字段多个值需求的最好的数据结构是倒排索引，也叫倒向索引，倒向索引还有对应的正向索引

     • 👅：实际上满足一个字段多个值的数据结构也包含正向索引，只是正向索引无法满足实时排名结果或者更高相关性的需求，不可能遍历每篇文档找到其中的关键词来判断是否相关，由此需要更好的倒排索引，即根据关键词来匹配更吻合的文档

   • 正向索引：搜索引擎将待搜索的文件和一个文件id对应形成k-v键值对，然后针对文档对文档中的关键词进行统计计数

     • 🔎：这种方式在搜索引擎上天文数字一般的文档数目条件下，无法满足实时返回排名结果的需求，搜索引擎会将正向索引重新构建为倒排索引

     

   • 倒排索引：将正向索引的文件ID对应关键词的映射转换为关键词到文件id的映射，每个关键词对应一系列的文件，这些文件中都出现该关键词

     

2. 倒排索引示例

   • 📜：对以下两个文档进行倒排索引

     • The quick brown fox jumped over the lazy dog

     • Quick brown foxes leap over lazy dogs in summer

   • 💡：​一个文档的倒排索引由文档中所有不重复词的列表构成，即每个不重复词都作为关键词，含有对应关键词的文档的id作为关键词值列表的一个元素，这样的关键词叫词条或者tokens【词条是索引中最小存储和查询的单元，英文文档中一般是一个单词，中文文档中一般是一个词组】，这个过程叫做分词，分词有专门的分词器，对中文和英文的分词器的分词规则是不同的，词条的集合被称为词典，词典一般有两种数据结构，一种是B+树，还有一种是HashMap

     • 倒排索引的过程

       • 先拿着检索词条去词典中检索是否存在，如果存在再去倒排表中检索词条对应的文档id的列表，拿着文档id进行匹配并拿到相关的文档数据

     • 两个文档所有的不重复词条的排序列表【倒排表】

       • 🔎：分词也会有一定策略，根据不同的业务需求不一定提取所有的不重复词，可能只抓人名等关键词，还有可能人名按需求会继续拆分出姓和名作为额外的索引词条，而且根据字段类型分词的策略也不同，当字段类型为keyword时对应值是不能进行分词的，需要完全匹配；如果字段类型是文本，就需要按照分词器的规则进行分词

       • 🔎：此外分词还可以设置ik分词器的不同分词算法，ik_max_word【表示对文档按照最细腻度的方式进行分词】和ik_smart【表示对文档按照最粗粒度的方式进行分词】

       

     • 此时搜索词条如quick brown，只需要查找对应词条包含的文档，每个词条都包含的文档或者词条匹配度最高的文档就是最相关的文档，在这种简单情况下，文档1的相关度比文档2高

       

     • 但是这种方式也存在问题，用户可能不认为单词的大小写有区分或者用户记错了对应关键词是大写还是小写；用户也可能压根就不记得关键词是单数还是复数，又或者具有相同词根但是形式不同的词；还有可能用户要表示jump的意思，但是确记成了leap或者不是相同词根但是意思相近的其他单词；在用户非常自信的检索关键字+Quick +fox【+前缀表示文档中必须出现该词条】，此时文档1为quick fox而文档2为Quick foxes导致用户不会查询到任何结果，这是很不友好的，为此发展出了以下的标准化解决方式

       核心是文档词条和查询字符串都必须标准化为相同的格式

       • 创建倒排索引的时候将关键字即词条规范为标准模式【如将词条统一为小写，将词汇统一提取为词根的格式，将同义词统一索引为相同的单词等，可能还会将文档中的姓名按姓和名拆分】，此时的文档对应的词条排序列表如下所示

         

       • 此时索引中不会在出现首字母大写的单词如Quick了，当直接使用用户搜索的词条Quick来匹配索引词条也会失败，因此用户检索的词条也需要和文档数据一样使用相同的标准化规则转换为+quick +fox的形式，这样两个文档都会匹配

          

文档搜索

1. 背景

   • 倒排索引的一个特点是被写入磁盘后是不可改变的，倒排索引的不变性会带来以下好处

     • 只要不更新索引，就不需要担心高并发多线程是多进程同时修改索引数据的问题，就不需要额外日常加锁

     • 因为磁盘的索引不会更新，索引被读入内核的文件系统缓存就会留在缓存即内存中而不需要关注索引的更新问题，此时大部分请求会直接请求内存，不会命中磁盘，会极大地提升系统性能

     • 其他和索引相关的缓存，如filter缓存，因为一个生命周期内索引数据不会发生变化，这些缓存数据也不会发生变化

     • 写入单个大的倒排索引允许数据被压缩，减少磁盘I/O和内存的使用量

   • 早期的全文检索会为整个文档建立很大的一个倒排索引并写入磁盘，直到新的索引被创建，旧的索引会被直接替换，即写入磁盘的倒排索引不会发生改变

     • 这种方式虽然有索引不变性带来的好处，但是一旦需要添加一个新的可被索引和搜索的文档，需要重建整个倒排索引，这对索引可被更新的频率有非常大的限制，也因此对索引的数据量造成很大地限制

2. 动态更新索引

   • 要保证倒排索引的不变性还要实现倒排索引的更新，解决办法是将最新时间的写操作全部写入一个新的倒排索引中，用来补充最近的修改，Lucene这个java库引入按段搜索的概念，每一段都是一个倒排索引，整个索引就是所有段的集合，将所有已知段列举在一个称为提交点的文件中

   • 按段搜索流程

     • 1️⃣：新文档被搜集并建立索引到内存索引缓存中

     • 2️⃣：缓存不时被提交，提交时一个新的段即一个追加的倒排索引被写入磁盘，一个包含新段名字的提交点被写入磁盘，所有文件系统缓存中等待的写入都被刷新到磁盘

     • 3️⃣：新的段开启，其中包含的文档也可以被搜索

     • 4️⃣：内存缓存被清空，等待接收新的文档

3. 搜索流程

   • 当一个查询被触发，所有已知的段按顺序被查询，此项统计对所有段的结果进行聚合

   • 段是不可改变的，既不能删除旧的段中的文档，也不能修改更新旧段中的文档，取而代之的是在每个提交点包含一个.del后缀文件，该文件中包含被删除文档的段信息，即一个文档被删除仅仅只是在.del文件中被标记删除，实际查询时被删除的文档仍然会被检索匹配到，但是会在最终结果被返回前从结果集中被剔除，文档更新也是标记删除旧文档，新版本文档被索引到一个新段中，两个版本的文档都可能被一个查询匹配到，但是旧版本文档在结果集返回以前会从结果集中被剔除

   • 此外段还有合并的概念，当多个段进行合并的时候，会将标记删除的索引和文档真正地进行物理删除，避免文档数据的过度冗余存储

近实时搜索

1. 不带文件系统缓存的写操作流程

   之前讲过了，大致总结

   • 客户端请求打到协调节点，协调节点计算主分片所在节点位置，转发写请求到主分片，主分片写操作结束转发完整更新后文档到所有的复制分片，每个复制分片写成功响应成功信息给主分片，主分片收到所有响应成功信息后将写入成功的信息响应给协调节点，协调节点响应成功信息给客户端

   • 此时，系统写入文档的延时是主分片写入延时+并行写入副本的最大延迟

     • 🔎：副本分片越多，数据越安全，但是可能发生的最大延迟事件可能更长【可能网络带宽资源占用越多吧】

   • 此时写入是在内存中创建索引，将索引加入内存的段中，只有段被写入磁盘以后文档数据才能供用户查询【那文档第80页上面为什么说内存中的新的段被开启，让它包含的文档可见以被搜索】，段被写入磁盘的过程被称为flush

     • ❓：啊？这里说这个新的段被flush到磁盘以后才会返回保存成功给客户端，那不是每个写操作都要创建一个新段并写入磁盘?

     • 🔑：这里是老师为了引入后续的近实时搜索进一步优化引出的内容，即这不是最终形态，因为每次对文档进行写操作都要将段写入磁盘文档才能被索引，

     • 👅：这里感觉应该理解成文档需要被存储到磁盘上，同时建立文档索引，此时才能通过索引找到文档的位置，从而将文档从磁盘响应给用户

   • 这种方式存在问题，通过这种方式每次添加文档都要将段通过fsync函数将缓冲区的数据立即写入磁盘，通过这样来保证断电的情况下尽可能不丢失数据，但是fsync操作的代价很大，每次索引一个文档都去执行一次会造成很大的性能问题

     • 🔎：此时，发展出一种在Elasticsearch和磁盘件使用文件系统缓存来解决使尚未刷新到磁盘的文档能被搜索以及拉长新的段被fsync到磁盘的时间间隔，同时还要能保证数据的安全性，在即使突然断电的情况下也能尽可能地保全文档数据

2. 带文件系统缓存的写操作流程

   • 1️⃣：内存索引缓冲区中的文档被写入到一个新的段中，然后这个新段会先写入文件系统缓存，稍后再被刷新到磁盘中

     • 🔎：写入文件系统缓存的代价比刷新到磁盘的代价低，且文件系统缓存中的文件可以向磁盘上的文件一样被打开和读取，通过文件系统缓存就可以使新段包含的文档在未进行一次完整提交时便对搜索可见

     • 🔎：这种将文档写入新段和文件系统缓存并打开一个新段的过程叫refresh，每个分片每秒会自动刷新一次，这也是Elasticsearch近实时搜索的含义，指的是对文档的写操作【新建、索引、删除文档数据】后文档并不是立即对搜索可见，但是会在一秒内变得可见

     • 🔎：当索引一个文档后很快地尝试搜索该文档，结果发现搜索不到，此时的解决办法是通过URI:/users/_refresh调用refresh API来执行一次手动将新段刷新到文件系统缓存【users是索引】，可以在测试的时候使用手动刷新，但不要在生产环境每次索引一个文档就去手动刷新，因为尽管刷新比提交少了很多操作，但是还是有性能开销

     • 🔎：并不是所有的情况都需要每秒刷新，使用Elasticsearch索引大量日志文件，此时应该重点优化索引速度，而不是近实时搜索，可以通过设置参数refresh_interval来降低新段刷新的频率，比如设置成30s刷新一次【理解成30s做一次检查，新段有写入数据就将新段写入文件系统缓存】，因为降低刷新频率能在一个新段上建立更大的倒排索引，而且过程中省去很多刷新开销，在生产环境建立一个大的新索引时也可以通过设置"refresh_interval": -1来关闭自动刷新功能

     • 🔎：设置刷新间隔

       • 设置刷新间隔为30s

         xxxxxxxxxx
         {
             "settings": {
                 "refresh_interval": "30s"
             }
         }
         

       • 关闭自动刷新，发送请求/users/_settings【PUT】

         xxxxxxxxxx
         { "refresh_interval": -1 }
         

       • 将刷新时间调整为默认值，发送请求/users/_settings【PUT】

         xxxxxxxxxx
         { "refresh_interval": "1s" }
         

持久化变更

1. 概念

   • 动态更新索引，一次完整的提交会将段刷新【flush】到磁盘并将提交的段写入一个包含所有段列表的提交点，如果没有fsync将数据从文件缓存系统刷新到硬盘，无法保证数据在程序正常退出或者断电的情况下依然存在

   • 在完整提交来确保数据的安全性外，我们还需要方案来确保两次提交之间文件系统缓冲的数据不会因为意外情况而发生丢失，由此衍生出了一个名为translog的事务日志，每一次对Elasticsearch进行操作时都会进行日志记录

2. 完整的一次提交流程

   • 1️⃣：一个文档被索引后会被添加到内存缓冲区，然后立即追加translog对应的事务日志，注意是文档先添加到内存然后再添加日志

     • 🔎：translog日志的作用是为还没有被刷新到磁盘的操作提供一个持久化记录，当ELasticsearch启动后，会从磁盘中使用最后一个提交点去恢复已知的最后一个段，并且重新执行translog中在最后一次提交后发生的变更操作，ELasticsearch在尝试恢复或者打开一个索引是，也会需要重放translog中的所有操作，日志越短，恢复越快，在重启节点或者关闭索引前执行手动flush的操作有益于重新打开或者恢复一个索引；

     • 🔎：在通过文档ID查询、删除、更新一个文档时，在尝试从相应的段中检索前会先检查translog中最近的变更来保证实时获取文档的最新版本

     • 🔎：默认情况下，translog每5秒钟就会被fsync刷新到硬盘，每次写请求【index, delete, update, bulk】完成之后主分片和复制分片也会执行fsync操作，当主分片和复制分片的translog被fsync到磁盘以后才会响应200OK给客户端 ；每次写操作请求后执行一个fsync会带来性能损失，bulk导入的fsync的性能开销相对其他较小，因为其在一次请求中平摊了大量文档的开销

     • 🔎：对于一些大容量偶尔丢失几秒数据无所谓的集群，可以考虑使用异步translog的fsync，即每次写操作以后都不进行日志的flush，只选用每5秒自动执行一次fsync，使用这种方式需要保证当集群发生崩溃时，丢失掉sync_interval时间段中的数据也无所谓，如果不能确定丢失数据的后果，最好是使用默认的参数"index.translog.durability": "request"来避免数据丢失

   • 2️⃣：refresh使分片每秒被刷新一次，整个刷新过程依次为

     • 内存缓冲区文档被写入一个新的段且没有进行fsync操作

       • 👅：感觉像段不是写入内存缓冲区，而是文档写入内存中的段，内存中的段不会以新的形式写入文件系统缓存，而是像一种注册的行为，让内存中段的数据能像文件一样被打开和读取，而刷新操作就是将内存缓冲区中的文档内容刷新追加到这个内存中的段中

       • 👅：卧槽，下面段合并说自动刷新流程每秒会创建一个新的段，现在只能认为每次refrush都会创建一个新的段，每次都将新段写入系统文件缓冲，最后提交的时候提交了非常多的段

     • 被刷新的段被打开，段内文档对搜索可见

     • 内存缓冲区被清空

   • 3️⃣：更多的文档重复上述过程追加到该段中，操作不断被追加到事务日志中

   • 4️⃣：当间隔一段时间或者事务日志累计到一定程度，索引被刷新【flush】，一个新的translog被创建，一个全量提交被执行，整个过程依次为

     执行一个提交并且节点translog的行为叫做flush，分片每30min会进行一次自动刷新，或者当translog太大时也会自动进行刷新

     • 所有内存缓存区的文档被写入一个新的段

     • 内存缓冲区被清空

     • 一个提交点被写入硬盘

     • 文件系统缓存通过fsync被刷新到磁盘

     • 老的translog事务日志被删除

段合并

1. 概念

   • 自动刷新流程refrush每秒都会创建一个新的段，段数目太多会导致文件句柄、内存和CPU运行周期消耗较大，此外每个搜索请求都要轮询检查每个段，段越多搜索速度就越慢，ELasticsearch通过段合并来解决这个问题，将小的段合并到大的段，将这些大的段合并到更大的段，段合并过程中将旧的已经删除的文档从文件系统中清除，在一个段中被删除的文档不会被拷贝到新的大段中

   • 在创建索引和搜索时会自动启动段合并

     • 合并过程中会选择部分大小相似的段，在后台将这些段合并到更大的段中

       • 👅：感觉像从文件系统缓冲将段合并成一个大段

     • 段合并结束老的段会被删除，新的段被刷新flush到磁盘，写入一个包含新段且排除旧的和较小的段的新提交点

     • 新的段被打开用来搜索，老的段被删除

     • 合并段需要消耗大量I/O和CPU资源，ELasticsearch在默认情况下对合并流程会进行资源限制，让搜索有足够的资源高效进行

文档分析

分析包含两个过程，将一块文本分成合适于倒排索引的独立词条，将这些词条统一为标准格式提高这些词条的可搜索性

分析器

分析器在执行分析过程时实际上封装了以下三个功能，分析器就是一个包中组合了以下三种函数的一个包装器，分析器将三种函数按照顺序执行

1. 字符过滤器

   • 字符串按顺序通过一系列字符过滤器，HTML清除字符过滤器能用来去掉所有的HTML标签等字符，并且像把&Aacute转换为相对应的Unicode字符Á，或者将一些特殊含义的字符如&转换成and等

   • 一个分析器可能有 0 个或者多个字符过滤器

2. 分词器

   • 字符串被分词器分成单个词条，最简单的分词器遇到空格和标点时将文本拆分成词条，正则分词器根据匹配正则表达式来分割文本，关键词分词器完整输出接收到的字符串，不做任何分词

   • 一个分析器必须有且只有一个唯一的分词器

3. Token过滤器

   • 分词器拆分出来的词条按顺序通过每个token过滤器，该过程可能会改变词条如将英文字母改成全部小写，删除a、and、the等无用词条，增加jump、leap等同义词词条

   • ES提供很多词单元过滤器，lowercase词过滤器将词条小写，stop过滤器是一个停用词过滤器【删除】，词干过滤器把单词转换成词干，ascii_folding过滤器移除变音符【把一个像très这样的词转换为tres】，ngram和edge_ngram词单元过滤器可以产生适合用于部分匹配或者自动补全的词单元

内置分析器

Elasticsearch附带了可以直接使用的预包装的分析器，以下是最重要的几个分析器，以下演示分析器处理下列文档的效果："Set the shape to semi-transparent by calling set_trans(5)"

1. 标准分析器

   • 标准分析器是Elasticsearch默认使用的分析器，根据Unicode联盟定义的单词边界划分文本，删除绝大部分标点，最后将词条全部小写，该分析器是分析各种语言文本最常用的版本，产生的对应词条：

     set, the, shape, to, semi, transparent, by, calling, set_trans, 5

2. 简单分析器

   • 在任何不是字母的地方分隔文本，并将词条小写，产生的对应词条：

     set, the, shape, to, semi, transparent, by, calling, set, trans

3. 空格分析器

   • 在空格的地方划分文本，产生的对应词条:

     Set, the, shape, to, semi-transparent, by, calling, set_trans(5)

4. 语言分析器

   • 特定的语言分析器可以考虑指定语言的特点，如英语分析器会删除对相关性没有影响的英语无用词如the、and等，还可以理解英语语法规则，提取英语单词的词干【transparent、 calling 和 set_trans 已经变为词根格式】，产生的对应词条:

     set, shape, semi, transpar, call, set_tran, 5

分析器使用场景

1. 一方面索引一个文档时，需要将文档的全文域使用分析器分析成词条来创建倒排索引，同时用户在全文域搜索的时候，需要将查询字符串使用相同的分析器经过相同的分析过程来保证搜索的词条格式和索引的词条格式一致，但是当用户查询一个精确值域查询的时候，不会分析查询的字符串，而是搜索指定的精确值

2. 区分全文域和精确值域，全文域会对查询字符串和文档做相同的分析过程来保证搜索词条和索引词条格式的一致，精确值域不会分析查询字符串，会直接搜索指定的精确值

   • ❓：精确值域使用什么分析器呢？

测试分析器

1. 使用analyze API查看文本是如何被分析的

   • 使用请求http://localhost:9200/_analyze【GET】可以查看文本如何被分析

     • 请求体json

       analyzer指定分析器，text指定要分析的文本

       xxxxxxxxxx
       {
           "analyzer": "standard",
           "text": "Text to analyze"
       }
       

     • 响应结果

       token是实际存储到索引中的词条，position指词条在原文本中出现的位置即从1开始的第几个词，start_offset和end_offset分别指明字符在原始包含空格字符串中的起始字节位置和字节结束位置，以空格作为一个词的结束且位置下标从0开始

       xxxxxxxxxx
       {
           "tokens": [
               {
                   "token": "text",
                   "start_offset": 0,
                   "end_offset": 4,
                   "type": "<ALPHANUM>",
                   "position": 1
               },
               {
                   "token": "to",
                   "start_offset": 5,
                   "end_offset": 7,
                   "type": "<ALPHANUM>",
                   "position": 2
               },
               {
                   "token": "analyze",
                   "start_offset": 8,
                   "end_offset": 15,
                   "type": "<ALPHANUM>",
                   "position": 3
               }
           ]
       }